HAL JPEG initialization and configuration functions migration

This section provides information about HAL JPEG initialization and configuration for STM32 HAL1 to HAL2 migration.

  • Open STM32CubeMX2 JPEG configuration panel.

  • Configure the SW layer HAL.

  • Configure the JPEG advanced features.

  • Configure the NVIC if the application requires the JPEG to be used in IT mode.

  • Configure the JPEG DMA(s) if the application requires the JPEG to be used in DMA mode.

  • Generate the code.

HAL JPEG configuration panel

Create a new project with the STM32CubeMX2, then start the initialization and the main configuration.

Project configuration panel

HAL JPEG advanced features configuration

Configure the advanced JPEG features.

JPEG advanced feature configuration

HAL DMA configuration

Configure the DMA as needed.

DMA TX configuration

JPEG DMA TX configuration

DMA RX configuration

JPEG DMA RX configuration

HAL NVIC configuration

Configure the NVIC in case of an interrupt.

JPEG NVIC configuration

Generated JPEG initialization and de-initialization sequences

The JPEG initialization sequence is generated in the mx_jpeg_init function in the mx_jpeg.c file under $YOUR_PROJECT_NAME$/$YOUR_PROJECT_NAME$_SW/generated/STM32Cube_CodeGen.

Related concepts:

Note

  • In HAL1, STM32CubeMX did not generate the JPEG encoding configurations (image height, image width, image quality, ColorSpace, ChromaSubsampling), so these had to be added manually before starting the JPEG initialization process.

  • In HAL2, STM32CubeMX2 gives user the permission to set these JPEG encoding configurations and the user only needs to add the encoder steps.

STM32CubeMX2 Generated: JPEG initialization and de-initialization sequences

Topic

Code Snippet HAL1

Code Snippet HAL2

Handle declaration 

JPEG_HandleTypeDef hjpeg;

static hal_jpeg_handle_t hJPEG;

Initialization and configuration sequence 

static void MX_JPEG_Init(void)
{
  hjpeg.Instance = JPEG;

  if (HAL_JPEG_Init(&hjpeg) != HAL_OK)
  {
    Error_Handler();
  }
}

void HAL_JPEG_MspInit(JPEG_HandleTypeDef* hjpeg)
{
  if(hjpeg->Instance==JPEG)
  {
    /* Peripheral clock enable */
    __HAL_RCC_JPEG_CLK_ENABLE();












    __HAL_RCC_GPDMA1_CLK_ENABLE();/* MX_DMA_Init */


    /* JPEG DMA Init */
    /* GPDMA1_REQUEST_JPEG_TX Init */
    handle_GPDMA1_Channel1.Instance = GPDMA1_Channel0;
    handle_GPDMA1_Channel1.Init.BlkHWRequest = DMA_BREQ_SINGLE_BURST;
    handle_GPDMA1_Channel1.Init.Request = GPDMA1_REQUEST_JPEG_TX;
    handle_GPDMA1_Channel1.Init.Direction = DMA_PERIPH_TO_MEMORY;
    handle_GPDMA1_Channel1.Init.SrcInc = DMA_SINC_FIXED;
    handle_GPDMA1_Channel1.Init.DestInc = DMA_DINC_INCREMENTED;
    handle_GPDMA1_Channel1.Init.SrcDataWidth = DMA_SRC_DATAWIDTH_WORD;
    handle_GPDMA1_Channel1.Init.DestDataWidth = DMA_DEST_DATAWIDTH_WORD;
    handle_GPDMA1_Channel1.Init.Priority = DMA_LOW_PRIORITY_HIGH_WEIGHT;
    handle_GPDMA1_Channel1.Init.SrcBurstLength = 8;
    handle_GPDMA1_Channel1.Init.DestBurstLength = 8;
    handle_GPDMA1_Channel1.Init.TransferAllocatedPort = DMA_SRC_ALLOCATED_PORT0|DMA_DEST_ALLOCATED_PORT1;
    handle_GPDMA1_Channel1.Init.TransferEventMode = DMA_TCEM_BLOCK_TRANSFER;
    handle_GPDMA1_Channel1.Init.Mode = DMA_NORMAL;
    if (HAL_DMA_Init(&handle_GPDMA1_Channel0) != HAL_OK)
    {
      Error_Handler();
    }

    if (HAL_DMA_ConfigChannelAttributes(&handle_GPDMA1_Channel0, DMA_CHANNEL_NPRIV) != HAL_OK)
    {
      Error_Handler();
    }


    HAL_NVIC_SetPriority(GPDMA1_Channel0_IRQn, 0, 0);/* MX_DMA_Init */
    HAL_NVIC_EnableIRQ(GPDMA1_Channel0_IRQn);/* MX_DMA_Init */

    /* Link the Transmit DMA handle to the JPEG handle */
    __HAL_LINKDMA(hjpeg, hdmaout, handle_GPDMA1_Channel0);

    /* JPEG interrupt Init */
    HAL_NVIC_SetPriority(JPEG_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(JPEG_IRQn);


  }
}

hal_jpeg_handle_t *mx_jpeg_init(void)
{
  hal_jpeg_config_t jpeg_config;

  if (HAL_JPEG_Init(&hJPEG, HAL_JPEG) != HAL_OK)
  {
    return NULL;
  }






  /* Peripheral clock enable */
  HAL_RCC_JPEG_EnableClock();

  /* Encoding Parameters */
  jpeg_config.input_format   = HAL_JPEG_IN_FORMAT_GRAYSCALE;
  jpeg_config.image_height   = 0;
  jpeg_config.image_width    = 0;
  jpeg_config.image_quality  = 1;
  if (HAL_JPEG_SetConfigEncoding(&hJPEG, &jpeg_config) != HAL_OK)
  {
    return NULL;
  }

  /* Configure the DMA TX */
  HAL_RCC_GPDMA1_EnableClock();

  hal_dma_direct_xfer_config_t xfer_cfg_jpeg_tx_dma;
  if (HAL_DMA_Init(&hGPDMA1_CH0, HAL_GPDMA1_CH0) != HAL_OK)
  {
    return NULL;
  }
  xfer_cfg_jpeg_tx_dma.request         = HAL_GPDMA1_REQUEST_JPEG_TX;
  xfer_cfg_jpeg_tx_dma.direction       = HAL_DMA_DIRECTION_PERIPH_TO_MEMORY;
  xfer_cfg_jpeg_tx_dma.src_inc         = HAL_DMA_SRC_ADDR_INCREMENTED;
  xfer_cfg_jpeg_tx_dma.dest_inc        = HAL_DMA_DEST_ADDR_FIXED;
  xfer_cfg_jpeg_tx_dma.src_data_width  = HAL_DMA_SRC_DATA_WIDTH_BYTE;
  xfer_cfg_jpeg_tx_dma.dest_data_width = HAL_DMA_DEST_DATA_WIDTH_WORD;
  xfer_cfg_jpeg_tx_dma.priority        = HAL_DMA_PRIORITY_LOW_WEIGHT_LOW;










  if (HAL_DMA_SetConfigPeriphDirectXfer(&hGPDMA1_CH0, &xfer_cfg_jpeg_tx_dma) != HAL_OK)
  {
    return NULL;
  }

  /* Enable the interruption for GPDMA1_CH0 */
  HAL_CORTEX_NVIC_SetPriority(GPDMA1_CH0_IRQn, HAL_CORTEX_NVIC_PREEMP_PRIORITY_0, HAL_CORTEX_NVIC_SUB_PRIORITY_0);
  HAL_CORTEX_NVIC_EnableIRQ(GPDMA1_CH0_IRQn);

  /* Link the Transmit DMA handle to the JPEG handle */
  HAL_JPEG_SetTxDMA(&hJPEG, &hGPDMA1_CH0);

  /* Enable the interruption for JPEG*/
  HAL_CORTEX_NVIC_SetPriority(JPEG_IRQn, HAL_CORTEX_NVIC_PREEMP_PRIORITY_0, HAL_CORTEX_NVIC_SUB_PRIORITY_0);
  HAL_CORTEX_NVIC_EnableIRQ(JPEG_IRQn);

  return &hJPEG;
}

Deinitialization sequence 

void MX_JPEG_DeInit(void)
{
    if (HAL_JPEG_DeInit(&hjpeg) != HAL_OK)
    {
        Error_Handler();
    }
}

void HAL_JPEG_MspDeInit(JPEG_HandleTypeDef* hjpeg)
{
  if(hjpeg->Instance==JPEG)
  {
    /* Peripheral clock disable */
    __HAL_RCC_JPEG_CLK_DISABLE();


    /* JPEG interrupt DeInit */
    HAL_NVIC_DisableIRQ(JPEG_IRQn);
  }
}

void mx_jpeg_hal_deinit(void)
{
  (void)HAL_JPEG_DeInit(&hJPEG);









  /* Peripheral clock disable */
  HAL_RCC_JPEG_Reset();
  HAL_RCC_JPEG_DisableClock();

  /* Disable the interruption for JPEG */
  HAL_CORTEX_NVIC_DisableIRQ(JPEG_IRQn);

}

IRQ handle function 

void JPEG_IRQHandler(void)
{
  HAL_JPEG_IRQHandler(&hjpeg);
}

void JPEG_IRQHandler(void)
{
  HAL_JPEG_IRQHandler(&hJPEG);
}